package com.bluedog.util;

import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextComponent;
import net.kyori.adventure.text.format.TextColor;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ColorUtils {

    // 正则表达式匹配六位或三位的十六进制颜色代码
    private static final Pattern HEX_COLOR_PATTERN = Pattern.compile("^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$");

    // 正则表达式模式，用于将文本中的十六进制颜色代码和其后的文本分割开来
    private static final Pattern HEX_COLOR_SPLITTER_ADVANCED = Pattern.compile("(#[A-Fa-f0-9]{3}(?:[A-Fa-f0-9]{3})?)((?:(?![#A-Fa-f0-9]{3}[A-Fa-f0-9]{3}|$).)*)");

    // 匹配以&开头的数字表示颜色代码进行分割
    private static final Pattern SEQUENCE_SPLITTER = Pattern.compile("(?:^|.*?)(?<!&)(&(\\d{1,3}))?(.*?)(?=(?<!&)(&\\d{1,3})|$)");

    // 匹配颜色代码
    public static final  Pattern COLOR_CODE_PATTERN = Pattern.compile("(&[0-9a-f]|#[A-Fa-f0-9]{6}|#[A-Fa-f0-9]{3})");

    private static final Map<String, String> colorMappings = new HashMap<>();

    static {
        colorMappings.put("&0", "#FFFFFF"); // WHITE
        colorMappings.put("&1", "#AAAAAA"); // GRAY (shifted down from &0)
        colorMappings.put("&2", "#555555"); // DARK_GRAY
        colorMappings.put("&3", "#5555FF"); // BLUE
        colorMappings.put("&4", "#55FF55"); // GREEN
        colorMappings.put("&5", "#55FFFF"); // AQUA
        colorMappings.put("&6", "#FF5555"); // RED
        colorMappings.put("&7", "#FF55FF"); // LIGHT_PURPLE
        colorMappings.put("&8", "#FFFF55"); // YELLOW
        colorMappings.put("&9", "#0000AA"); // DARK_BLUE (original &1)
        colorMappings.put("&a", "#00AA00"); // DARK_GREEN (original &2)
        colorMappings.put("&b", "#00AAAA"); // DARK_AQUA (original &3)
        colorMappings.put("&c", "#AA0000"); // DARK_RED (original &4)
        colorMappings.put("&d", "#AA00AA"); // DARK_PURPLE (original &5)
        colorMappings.put("&e", "#FFAA00"); // GOLD (original &6)
        colorMappings.put("&f", "#000000"); // BLACK (original &7)
    }

    /**
     * 判断给定的字符串是否为有效的十六进制颜色代码。
     *
     * @param colorStr 要检查的字符串
     * @return 如果字符串是有效的十六进制颜色代码则返回true，否则返回false
     */
    public static boolean isValidHexString(String colorStr) {
        Matcher matcher = HEX_COLOR_PATTERN.matcher(colorStr);
        return matcher.matches();
    }


    /**
     * 按照十六进制颜色代码将文本分割成多个部分，并为无颜色代码的初始文本指定默认颜色。
     *
     * @param text 输入文本，可能以无颜色代码的文本开始，随后包含一个或多个十六进制颜色代码及其相关内容
     * @Param defaultColor 默认颜色代码，用于处理没有颜色代码的初始文本
     * @return 一个列表，每个元素是一个二维数组，第一个元素是颜色代码（或默认的白色#FFFFFF），第二个元素是对应的文本描述。
     */
    public static List<String[]> splitTextWithHexColor(String text, String defaultColor) {
        Matcher matcher = HEX_COLOR_SPLITTER_ADVANCED.matcher(text);
        List<String[]> parts = new ArrayList<>();

        boolean isFirstMatch = matcher.find();

        if (!isFirstMatch) {
            // 如果没有找到任何颜色代码，整个文本视为默认颜色
            parts.add(new String[]{defaultColor, text.trim()});
        } else {
            if (matcher.start() == 0) {
                // 第一个匹配就是颜色代码，意味着前面没有默认颜色的文本
                parts.add(new String[]{matcher.group(1), matcher.group(2)});
            } else {
                // 处理开始前的文本（如果有）
                parts.add(new String[]{defaultColor, text.substring(0, matcher.start()).trim()});
            }

            do {
                // 添加当前颜色代码及其后的文本，确保包括了颜色代码后的所有内容直到下一个颜色代码或文本结束
                parts.add(new String[]{matcher.group(1), matcher.group(2)});
            } while (matcher.find());

        }

        return parts;
        }

    /**
     * 按照序列号（如&1, &2等）将文本分割成多个部分，并为序列号前的文本指定默认序号&0。
     *
     * @param text 输入文本，包含序列号及其后的文本内容
     * @return 一个列表，每个元素是一个二维数组，第一个元素是序列号（或默认的&0），第二个元素是对应的文本描述。
     */
    public static List<String[]> splitTextBySequence(String text) {
        Matcher matcher = SEQUENCE_SPLITTER.matcher(text);
        List<String[]> parts = new ArrayList<>();

        boolean isFirst = true;
        while (matcher.find()) {
            String sequence = matcher.group(2) != null ? "&" + matcher.group(2) : "&0";
            String content = matcher.group(3);
            // 确保不添加空字符串项，除非是文本的开始处的默认&0
            if (!isFirst && content.isEmpty()) continue;
            parts.add(new String[]{sequence, content});
            isFirst = false;
        }

        // 确保最后一个非空字符串被正确处理，避免因正则表达式结束条件导致的丢失
        if (matcher.hitEnd() && !text.endsWith(" ")) {
            String lastContent = text.substring(matcher.end());
            if (!lastContent.isEmpty()) {
                parts.add(new String[]{"&0", lastContent});
            }
        }

        return parts;
    }

    /**
     * 解析文本中的颜色代码十六进制颜色和&0-&9 &a-&f颜色序列号，并将其与相应文本段落配对。
     * @param text 待解析的原始文本。
     * @param defaultColor 默认颜色，如果不指定，则默认为白色。
     * @return 包含颜色代码和对应文本的配对列表。
     */
    public static List<String[]> parseTextWithColors(String text, String... defaultColor) {
        List<String[]> resultList = new ArrayList<>(); // 存储结果的列表
        String currentColor = "#FFFFFF"; // 默认颜色
        if (defaultColor.length > 0){
            currentColor = defaultColor[0];
        }

        Matcher matcher = COLOR_CODE_PATTERN.matcher(text);
        int lastMatchEnd = 0; // 上一次匹配结束的位置

        // 遍历文本中的颜色代码
        while (matcher.find()) {
            String match = matcher.group();  // 获取匹配到的颜色代码
            int start = matcher.start(); // 匹配起始位置

            // 如果当前颜色代码前有文本，添加到结果列表中
            if (start > lastMatchEnd) {
                String textSegment = text.substring(lastMatchEnd, start); // No trim to keep spaces
                if (!textSegment.isEmpty()) {
                    resultList.add(new String[]{currentColor, textSegment});
                }
            }

            // 根据匹配到的颜色代码更新当前颜色
            if (match.startsWith("&")) {
                currentColor = colorMappings.getOrDefault(match, currentColor);
            } else if (match.startsWith("#")) {
                currentColor = match;
            }

            lastMatchEnd = matcher.end();
        }

        // 添加文本末尾的剩余部分，同样保留空格
        if (lastMatchEnd < text.length()) {
            String trailingText = text.substring(lastMatchEnd); // No trim to keep spaces
            if (!trailingText.isEmpty()) {
                resultList.add(new String[]{currentColor, trailingText});
            }
        }

        return resultList;
    }


    /**
     * 解析文本中的颜色代码十六进制颜色和&0-&9 &a-&f颜色序列号，并将其与相应文本段落配对。
     * @param text 待解析的原始文本。
     * @param defaultColor 默认颜色，如果不指定，则默认为白色。
     * @return 返回组装的TextComponent.Builder对象。
     */
    public static TextComponent.Builder getTextBuilderWithColors(String text, String... defaultColor) {
        TextComponent.Builder parsedText = Component.text();
        String currentColor = "#FFFFFF"; // 默认颜色
        if (defaultColor.length > 0 && isValidHexString(defaultColor[0])){
            currentColor = defaultColor[0];
        }

        Matcher matcher = COLOR_CODE_PATTERN.matcher(text);
        int lastMatchEnd = 0; // 上一次匹配结束的位置

        // 遍历文本中的颜色代码
        while (matcher.find()) {
            String match = matcher.group();  // 获取匹配到的颜色代码
            int start = matcher.start(); // 匹配起始位置

            // 如果当前颜色代码前有文本，添加到结果列表中
            if (start > lastMatchEnd) {
                String textSegment = text.substring(lastMatchEnd, start);
                if (!textSegment.isEmpty()) {
                    parsedText.append(Component.text(textSegment, TextColor.fromHexString(currentColor)));
                }
            }

            // 根据匹配到的颜色代码更新当前颜色
            if (match.startsWith("&")) {
                currentColor = colorMappings.getOrDefault(match, currentColor);
            } else if (match.startsWith("#")) {
                currentColor = match;
            }

            lastMatchEnd = matcher.end();
        }

        // 添加文本末尾的剩余部分
        if (lastMatchEnd < text.length()) {
            String trailingText = text.substring(lastMatchEnd); // No trim to keep spaces
            if (!trailingText.isEmpty()) {
                parsedText.append(Component.text(trailingText, TextColor.fromHexString(currentColor)));
            }
        }

        return parsedText;
    }
}
